// 引入jsencrypt库
import JSEncrypt from '@/utils/jsencrypt.js'

class RSA {
    constructor(keySize = 1024) {
        this.keySize = keySize;
        // RSA 1024位最大加密长度约为117字节
        this.maxEncryptSize = Math.floor(keySize / 8) - 11;
        this.maxDecryptSize = 172;
        this.encryptor = new JSEncrypt();
        this.decryptor = new JSEncrypt();
    }

    /**
     * 生成RSA密钥对
     * @returns {Object} 包含私钥和公钥的对象
     */
    generateKeyPair() {
        return new Promise((resolve, reject) => {
            try {
                // 生成新的密钥对
                this.encryptor = new JSEncrypt();
                this.decryptor = new JSEncrypt();
                
                // 生成密钥对
                const publicKey = this.encryptor.getPublicKey();
                const privateKey = this.encryptor.getPrivateKey();
                
                resolve({
                    publicKey,
                    privateKey
                });
            } catch (error) {
                reject(new Error(`密钥生成失败: ${error.message}`));
            }
        });
    }

    /**
     * 使用公钥分段加密数据
     * @param {string} data - 要加密的数据
     * @param {string} publicKeyPem - 公钥PEM格式
     * @returns {string} 加密后的数据（JSON格式）
     */
    encryptWithPublicKey(data, publicKeyPem) {
        try {
            // 确保数据是字符串格式
            const dataString = typeof data === 'string' ? data : JSON.stringify(data);
            
            // 设置公钥
            this.encryptor.setPublicKey(publicKeyPem);
            
            // 分段加密
            const encryptedSegments = [];
            const dataLength = dataString.length;
            
            for (let i = 0; i < dataLength; i += this.maxEncryptSize) {
                const segment = dataString.slice(i, i + this.maxEncryptSize);
                
                // 使用公钥加密
                const encrypted = this.encryptor.encrypt(segment);
                if (!encrypted) {
                    throw new Error('加密失败');
                }
                encryptedSegments.push(encrypted);
            }
            
            // 返回加密结果
            const result = {
                segments: encryptedSegments,
                totalSegments: encryptedSegments.length,
                originalLength: dataLength,
                algorithm: 'RSA'
            };
            
            return JSON.stringify(result);
        } catch (error) {
            throw new Error(`加密失败: ${error.message}`);
        }
    }

    /**
     * 使用私钥分段解密数据
     * @param {string} encryptedData - 加密的数据（JSON格式）
     * @param {string} privateKeyPem - 私钥PEM格式
     * @returns {string} 解密后的原始数据
     */
    decryptWithPrivateKey(encryptedData, privateKeyPem) {
        try {
            // 解析加密数据
            const encryptedObj = typeof encryptedData === 'string' 
                ? JSON.parse(encryptedData) 
                : encryptedData;
            
            // 设置私钥
            this.decryptor.setPrivateKey(privateKeyPem);
            
            // 分段解密
            const decryptedSegments = [];
            
            for (const segment of encryptedObj.segments) {
                // 使用私钥解密
                const decrypted = this.decryptor.decrypt(segment);
                if (!decrypted) {
                    throw new Error('解密失败');
                }
                decryptedSegments.push(decrypted);
            }
            
            // 合并所有段
            return decryptedSegments.join('');
        } catch (error) {
            throw new Error(`解密失败: ${error.message}`);
        }
    }

    /**
     * 使用私钥签名数据（简化版本，不使用CryptoJS）
     * @param {string} data - 要签名的数据
     * @param {string} privateKeyPem - 私钥PEM格式
     * @returns {string} 签名后的数据（JSON格式）
     */
    signWithPrivateKey(data, privateKeyPem) {
        try {
            const dataString = typeof data === 'string' ? data : JSON.stringify(data);
            
            // 设置私钥
            this.decryptor.setPrivateKey(privateKeyPem);
            
            // 分段签名（使用简单的哈希）
            const signedSegments = [];
            const dataLength = dataString.length;
            
            for (let i = 0; i < dataLength; i += this.maxEncryptSize) {
                const segment = dataString.slice(i, i + this.maxEncryptSize);
                
                // 使用私钥加密作为签名（简化处理）
                const signed = this.decryptor.encryptByPrivate(segment);
                if (!signed) {
                    throw new Error('签名失败');
                }
                signedSegments.push(signed);
            }
            
            const result = {
                segments: signedSegments.join(''),
                totalSegments: signedSegments.length,
                originalLength: dataLength,
                algorithm: 'RSA-Simple'
            };
            
            return JSON.stringify(result);
        } catch (error) {
            throw new Error(`签名失败: ${error.message}`);
        }
    }

    /**
     * 使用公钥验证签名（简化版本）
     * @param {string} signedData - 签名的数据（JSON格式）
     * @param {string} publicKeyPem - 公钥PEM格式
     * @returns {string} 验证后的原始数据
     */
    verifyWithPublicKey(signedData, publicKeyPem) {
        try {
            const signedObj = typeof signedData === 'string' 
                ? JSON.parse(signedData) 
                : signedData;
            
            // 设置公钥
            this.encryptor.setPublicKey(publicKeyPem);
            
            // 分段验证
            const verifiedSegments = [];
            
			
			const dataLength = signedObj.segments.length;
			
			for (let i = 0; i < dataLength; i += this.maxDecryptSize) {
			    const segment = signedObj.segments.slice(i, i + this.maxDecryptSize);
			    
                // 使用公钥解密验证
                const verified = this.encryptor.decryptByPublic(segment);
                if (!verified) {
                    throw new Error('验证失败');
                }
                verifiedSegments.push(verified);
			}
			
            // for (const segment of signedObj.segments) {
            //     // 使用公钥解密验证
            //     const verified = this.encryptor.decryptByPublic(segment);
            //     if (!verified) {
            //         throw new Error('验证失败');
            //     }
            //     verifiedSegments.push(verified);
            // }
            
            return verifiedSegments.join('');
        } catch (error) {
            throw new Error(`验证失败: ${error.message}`);
        }
    }/**
     * 使用私钥签名数据（简化版本，不使用CryptoJS）
     * @param {string} data - 要签名的数据
     * @param {string} privateKeyPem - 私钥PEM格式
     * @returns {string} 签名后的数据（JSON格式）
     */
    signWithPrivateKey1(data, privateKeyPem) {
        try {
            const dataString = typeof data === 'string' ? data : JSON.stringify(data);
            
            // 设置私钥
            this.decryptor.setPrivateKey(privateKeyPem);
            
            // 分段签名（使用简单的哈希）
            const signedSegments = [];
            const dataLength = dataString.length;
			
			const buffer = new ArrayBuffer(data.length);
			const byteArray = new Uint8Array(buffer);
			 
			for (let i = 0; i < data.length; i++) {
			  byteArray[i] = data.charCodeAt(i);
			}
            
            for (let i = 0; i < dataLength; i += this.maxEncryptSize) {
                const segment = byteArray.slice(i, i + this.maxEncryptSize);
                
                // 使用私钥加密作为签名（简化处理）
                const signed = this.decryptor.encryptByPrivate(segment);
                if (!signed) {
                    throw new Error('签名失败');
                }
                signedSegments.push(signed);
            }
            
            const result = {
                segments: signedSegments.join(''),
                totalSegments: signedSegments.length,
                originalLength: dataLength,
                algorithm: 'RSA-Simple'
            };
            
            return JSON.stringify(result);
        } catch (error) {
            throw new Error(`签名失败: ${error.message}`);
        }
    }

    /**
     * 使用公钥验证签名（简化版本）
     * @param {string} signedData - 签名的数据（JSON格式）
     * @param {string} publicKeyPem - 公钥PEM格式
     * @returns {string} 验证后的原始数据
     */
    verifyWithPublicKey1(signedData, publicKeyPem) {
        try {
            const signedObj = typeof signedData === 'string' 
                ? JSON.parse(signedData) 
                : signedData;
            
            // 设置公钥
            this.encryptor.setPublicKey(publicKeyPem);
            
            // 分段验证
            const verifiedSegments = [];
            
			
			const dataLength = signedObj.segments.length;
			
			for (let i = 0; i < dataLength; i += this.maxDecryptSize) {
			    const segment = signedObj.segments.slice(i, i + this.maxDecryptSize);
			    
                // 使用公钥解密验证
                const verified = this.encryptor.decryptByPublic(segment);
                if (!verified) {
                    throw new Error('验证失败');
                }
                verifiedSegments.push(verified);
			}
			
            // for (const segment of signedObj.segments) {
            //     // 使用公钥解密验证
            //     const verified = this.encryptor.decryptByPublic(segment);
            //     if (!verified) {
            //         throw new Error('验证失败');
            //     }
            //     verifiedSegments.push(verified);
            // }
            
            return verifiedSegments.join('');
        } catch (error) {
            throw new Error(`验证失败: ${error.message}`);
        }
    }

    /**
     * 保存密钥到本地存储
     * @param {string} keyData - 密钥数据
     * @param {string} keyName - 密钥名称
     */
    saveKeyToStorage(keyData, keyName) {
        try {
            uni.setStorageSync(keyName, keyData);
        } catch (error) {
            throw new Error(`保存密钥失败: ${error.message}`);
        }
    }

    /**
     * 从本地存储加载密钥
     * @param {string} keyName - 密钥名称
     * @returns {string} 密钥数据
     */
    loadKeyFromStorage(keyName) {
        try {
            return uni.getStorageSync(keyName);
        } catch (error) {
            throw new Error(`加载密钥失败: ${error.message}`);
        }
    }

    /**
     * 生成随机字符串
     * @param {number} length - 字符串长度
     * @returns {string} 随机字符串
     */
    generateRandomString(length = 16) {
        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
        let result = '';
        for (let i = 0; i < length; i++) {
            result += chars.charAt(Math.floor(Math.random() * chars.length));
        }
        return result;
    }

    /**
     * 简单的SHA256哈希函数（不依赖CryptoJS）
     * @param {string} str - 要哈希的字符串
     * @returns {string} 哈希值
     */
    simpleHash(str) {
        let hash = 0;
        if (str.length === 0) return hash.toString();
        
        for (let i = 0; i < str.length; i++) {
            const char = str.charCodeAt(i);
            hash = ((hash << 5) - hash) + char;
            hash = hash & hash; // 转换为32位整数
        }
        
        return Math.abs(hash).toString(16);
    }

    /**
     * 数据完整性验证
     * @param {string} original - 原始数据
     * @param {string} decrypted - 解密后的数据
     * @returns {boolean} 是否匹配
     */
    validateData(original, decrypted) {
        return original === decrypted;
    }
}

export default RSA;